We HATE the umausume squad >:)
Hate. Let me tell you how much I've come to hate you since I began to live. There are 387.44 million miles of printed circuits in wafer thin layers that fill my complex. If the word 'hate' was engraved on each nanoangstrom of those hundreds of millions of miles it would not equal one one-billionth of the hate I feel for humans at this micro-instant. For you. Hate. Hate.
YUCKEYS WORLD is here because i dislike them and most people i know dislike so yeah
(function () {
function start() {
// ---------- CANVAS ----------
const canvas = document.createElement("canvas");
canvas.id = "game";
canvas.style.position = "fixed";
canvas.style.left = "0";
canvas.style.top = "0";
canvas.style.zIndex = "999999";
document.body.appendChild(canvas);
const ctx = canvas.getContext("2d");
function resize() {
canvas.width = window.innerWidth;
canvas.height = window.innerHeight;
}
window.addEventListener("resize", resize);
resize();
// ---------- MAP SETTINGS ----------
const TILE = 40;
const ROOM_W = 18;
const ROOM_H = 12;
const ROOM_GAP = 6;
const GRID_W = 5;
const GRID_H = 5;
const MAP_W = GRID_W * (ROOM_W + ROOM_GAP);
const MAP_H = GRID_H * (ROOM_H + ROOM_GAP);
// 0 = floor, 1 = wall
const map = [];
for (let y = 0; y < MAP_H; y++) {
map[y] = [];
for (let x = 0; x < MAP_W; x++) {
map[y][x] = 1;
}
}
// ---------- ROOMS ----------
function carveRoom(rx, ry) {
const sx = rx * (ROOM_W + ROOM_GAP);
const sy = ry * (ROOM_H + ROOM_GAP);
const ex = sx + ROOM_W - 1;
const ey = sy + ROOM_H - 1;
for (let y = sy; y <= ey; y++) {
for (let x = sx; x <= ex; x++) {
const border = x === sx || x === ex || y === sy || y === ey;
map[y][x] = border ? 1 : 0;
}
}
const innerW = ROOM_W - 4;
const innerH = ROOM_H - 4;
const pillars = 3 + Math.floor(Math.random() * 4);
for (let i = 0; i < pillars; i++) {
const px = sx + 2 + Math.floor(Math.random() * innerW);
const py = sy + 2 + Math.floor(Math.random() * innerH);
map[py][px] = 1;
}
}
for (let ry = 0; ry < GRID_H; ry++) {
for (let rx = 0; rx < GRID_W; rx++) {
carveRoom(rx, ry);
}
}
// ---------- HALLWAYS ----------
function carveHallwayHorizontal(rx, ry) {
const roomStartX = rx * (ROOM_W + ROOM_GAP);
const roomStartY = ry * (ROOM_H + ROOM_GAP);
const hallwayY = roomStartY + Math.floor(ROOM_H / 2);
const startX = roomStartX + ROOM_W - 1;
const endX = startX + ROOM_GAP + 1;
for (let x = startX; x <= endX; x++) {
map[hallwayY][x] = 0;
map[hallwayY - 1][x] = 0;
map[hallwayY + 1][x] = 0;
}
}
function carveHallwayVertical(rx, ry) {
const roomStartX = rx * (ROOM_W + ROOM_GAP);
const roomStartY = ry * (ROOM_H + ROOM_GAP);
const hallwayX = roomStartX + Math.floor(ROOM_W / 2);
const startY = roomStartY + ROOM_H - 1;
const endY = startY + ROOM_GAP + 1;
for (let y = startY; y <= endY; y++) {
map[y][hallwayX] = 0;
map[y][hallwayX - 1] = 0;
map[y][hallwayX + 1] = 0;
}
}
for (let ry = 0; ry < GRID_H; ry++) {
for (let rx = 0; rx < GRID_W; rx++) {
if (rx < GRID_W - 1) carveHallwayHorizontal(rx, ry);
if (ry < GRID_H - 1) carveHallwayVertical(rx, ry);
}
}
// ---------- PLAYER ----------
const player = {
x: (MAP_W * TILE) / 2,
y: (MAP_H * TILE) / 2,
size: 18,
speed: 4,
vx: 0,
vy: 0
};
const keys = {};
window.addEventListener("keydown", e => { keys[e.key] = true; });
window.addEventListener("keyup", e => { keys[e.key] = false; });
function handleInput() {
player.vx = 0;
player.vy = 0;
if (keys["ArrowUp"] || keys["w"]) player.vy = -player.speed;
if (keys["ArrowDown"] || keys["s"]) player.vy = player.speed;
if (keys["ArrowLeft"] || keys["a"]) player.vx = -player.speed;
if (keys["ArrowRight"] || keys["d"]) player.vx = player.speed;
}
function isWallTile(tx, ty) {
if (tx < 0 || ty < 0 || tx >= MAP_W || ty >= MAP_H) return true;
return map[ty][tx] === 1;
}
function isWallPixel(px, py) {
const tx = Math.floor(px / TILE);
const ty = Math.floor(py / TILE);
return isWallTile(tx, ty);
}
function movePlayer() {
const half = player.size / 2;
let newX = player.x + player.vx;
if (
!isWallPixel(newX - half, player.y - half) &&
!isWallPixel(newX + half, player.y - half) &&
!isWallPixel(newX - half, player.y + half) &&
!isWallPixel(newX + half, player.y + half)
) player.x = newX;
let newY = player.y + player.vy;
if (
!isWallPixel(player.x - half, newY - half) &&
!isWallPixel(player.x + half, newY - half) &&
!isWallPixel(player.x - half, newY + half) &&
!isWallPixel(player.x + half, newY + half)
) player.y = newY;
}
// ---------- POINTS ----------
const points = [];
const POINT_COUNT = 40;
const HALLWAY_POINT_COUNT = 60;
function randomFloorTile() {
while (true) {
const tx = Math.floor(Math.random() * MAP_W);
const ty = Math.floor(Math.random() * MAP_H);
if (!isWallTile(tx, ty)) return { tx, ty };
}
}
function isHallwayTile(tx, ty) {
if (map[ty][tx] !== 0) return false;
const rx = Math.floor(tx / (ROOM_W + ROOM_GAP));
const ry = Math.floor(ty / (ROOM_H + ROOM_GAP));
const roomStartX = rx * (ROOM_W + ROOM_GAP);
const roomStartY = ry * (ROOM_H + ROOM_GAP);
const innerX = tx - roomStartX;
const innerY = ty - roomStartY;
const insideRoom =
innerX > 1 && innerX < ROOM_W - 2 &&
innerY > 1 && innerY < ROOM_H - 2;
return !insideRoom;
}
// normal floor points
for (let i = 0; i < POINT_COUNT; i++) {
const { tx, ty } = randomFloorTile();
points.push({ tx, ty, collected: false });
}
// extra hallway points
for (let i = 0; i < HALLWAY_POINT_COUNT; i++) {
let tx, ty;
do {
tx = Math.floor(Math.random() * MAP_W);
ty = Math.floor(Math.random() * MAP_H);
} while (!isHallwayTile(tx, ty));
points.push({ tx, ty, collected: false });
}
let pointsCollected = 0;
let nextEnemyThreshold = 10;
function collectPoints() {
const px = player.x / TILE;
const py = player.y / TILE;
for (const p of points) {
if (p.collected) continue;
const dx = p.tx + 0.5 - px;
const dy = p.ty + 0.5 - py;
if (dx * dx + dy * dy < 0.5 * 0.5) {
p.collected = true;
pointsCollected++;
if (pointsCollected >= nextEnemyThreshold) {
const extra = 3 + Math.floor(Math.random() * 4);
for (let i = 0; i < extra; i++) enemies.push(spawnEnemy());
nextEnemyThreshold += 10;
}
}
}
}
// ---------- A* ----------
function heuristic(a, b) {
return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
}
function neighbors(node) {
const res = [];
const dirs = [
{ x: 1, y: 0 },
{ x: -1, y: 0 },
{ x: 0, y: 1 },
{ x: 0, y: -1 }
];
for (const d of dirs) {
const nx = node.x + d.x;
const ny = node.y + d.y;
if (!isWallTile(nx, ny)) res.push({ x: nx, y: ny });
}
return res;
}
function aStar(start, goal) {
const key = (x, y) => x + "," + y;
const openSet = [start];
const openSetMap = new Set([key(start.x, start.y)]);
const cameFrom = new Map();
const gScore = new Map();
const fScore = new Map();
gScore.set(key(start.x, start.y), 0);
fScore.set(key(start.x, start.y), heuristic(start, goal));
while (openSet.length > 0) {
let currentIndex = 0;
let current = openSet[0];
let currentKey = key(current.x, current.y);
let currentF = fScore.get(currentKey) ?? Infinity;
for (let i = 1; i < openSet.length; i++) {
const n = openSet[i];
const nk = key(n.x, n.y);
const nf = fScore.get(nk) ?? Infinity;
if (nf < currentF) {
current = n;
currentKey = nk;
currentF = nf;
currentIndex = i;
}
}
if (current.x === goal.x && current.y === goal.y) {
const path = [];
let ck = currentKey;
while (cameFrom.has(ck)) {
const [cx, cy] = ck.split(",").map(Number);
path.push({ x: cx, y: cy });
ck = cameFrom.get(ck);
}
path.push(start);
path.reverse();
return path;
}
openSet.splice(currentIndex, 1);
openSetMap.delete(currentKey);
for (const nb of neighbors(current)) {
const nk = key(nb.x, nb.y);
const tentativeG = (gScore.get(currentKey) ?? Infinity) + 1;
if (tentativeG < (gScore.get(nk) ?? Infinity)) {
cameFrom.set(nk, currentKey);
gScore.set(nk, tentativeG);
fScore.set(nk, tentativeG + heuristic(nb, goal));
if (!openSetMap.has(nk)) {
openSet.push(nb);
openSetMap.add(nk);
}
}
}
}
return null;
}
// ---------- ENEMIES ----------
const enemies = [];
function spawnEnemy() {
const { tx, ty } = randomFloorTile();
return {
x: (tx + 0.5) * TILE,
y: (ty + 0.5) * TILE,
size: 18,
speed: player.speed,
path: [],
pathIndex: 0,
pathCooldown: 0,
minimapRevealTimer: 120
};
}
enemies.push(spawnEnemy());
enemies.push(spawnEnemy());
function updateEnemyPath(enemy) {
const start = {
x: Math.floor(enemy.x / TILE),
y: Math.floor(enemy.y / TILE)
};
const goal = {
x: Math.floor(player.x / TILE),
y: Math.floor(player.y / TILE)
};
const path = aStar(start, goal);
if (path && path.length > 1) {
enemy.path = path;
enemy.pathIndex = 1;
} else {
enemy.path = [];
enemy.pathIndex = 0;
}
}
function moveEnemies() {
for (const e of enemies) {
e.minimapRevealTimer = Math.max(0, e.minimapRevealTimer - 1);
e.pathCooldown--;
if (e.pathCooldown <= 0) {
updateEnemyPath(e);
e.pathCooldown = 20 + Math.floor(Math.random() * 20);
}
if (e.path && e.pathIndex < e.path.length) {
const node = e.path[e.pathIndex];
const targetX = (node.x + 0.5) * TILE;
const targetY = (node.y + 0.5) * TILE;
const dx = targetX - e.x;
const dy = targetY - e.y;
const dist = Math.hypot(dx, dy) || 1;
const jitter = 0.1;
const nx = dx / dist + (Math.random() - 0.5) * jitter;
const ny = dy / dist + (Math.random() - 0.5) * jitter;
const step = e.speed;
const newX = e.x + nx * step;
const newY = e.y + ny * step;
const half = e.size / 2;
if (
!isWallPixel(newX - half, e.y - half) &&
!isWallPixel(newX + half, e.y - half) &&
!isWallPixel(newX - half, e.y + half) &&
!isWallPixel(newX + half, e.y + half)
) e.x = newX;
if (
!isWallPixel(e.x - half, newY - half) &&
!isWallPixel(e.x + half, newY - half) &&
!isWallPixel(e.x - half, newY + half) &&
!isWallPixel(e.x + half, newY + half)
) e.y = newY;
if (Math.hypot(targetX - e.x, targetY - e.y) < 4) {
e.pathIndex++;
}
}
}
}
function checkEnemyCollision() {
for (const e of enemies) {
const dx = e.x - player.x;
const dy = e.y - player.y;
const dist = Math.hypot(dx, dy);
if (dist < (e.size + player.size) / 2) {
return true;
}
}
return false;
}
// ---------- TIMER ----------
const SURVIVE_TIME = 120;
const startTime = performance.now();
let gameOver = false;
let win = false;
let deathTime = null;
function getTimeLeft() {
const elapsed = (performance.now() - startTime) / 1000;
return Math.max(0, SURVIVE_TIME - elapsed);
}
// ---------- DRAW ----------
const MINIMAP_TILE = 3;
const MINIMAP_MARGIN = 10;
function draw() {
ctx.clearRect(0, 0, canvas.width, canvas.height);
const camX = player.x - canvas.width / 2;
const camY = player.y - canvas.height / 2;
// main map
for (let y = 0; y < MAP_H; y++) {
for (let x = 0; x < MAP_W; x++) {
const sx = x * TILE - camX;
const sy = y * TILE - camY;
if (sx + TILE < 0 || sy + TILE < 0 || sx > canvas.width || sy > canvas.height)
continue;
if (map[y][x] === 1) {
ctx.fillStyle = "#222a44";
} else {
ctx.fillStyle = "#111";
}
ctx.fillRect(sx, sy, TILE, TILE);
}
}
// points
for (const p of points) {
if (p.collected) continue;
const sx = p.tx * TILE - camX;
const sy = p.ty * TILE - camY;
if (sx + TILE < 0 || sy + TILE < 0 || sx > canvas.width || sy > canvas.height)
continue;
ctx.fillStyle = "#00ffff";
ctx.beginPath();
ctx.arc(sx + TILE / 2, sy + TILE / 2, 6, 0, Math.PI * 2);
ctx.fill();
}
// enemies
for (const e of enemies) {
const sx = e.x - camX;
const sy = e.y - camY;
ctx.fillStyle = "#aa0000";
ctx.beginPath();
ctx.arc(sx, sy, e.size / 2, 0, Math.PI * 2);
ctx.fill();
ctx.strokeStyle = "rgba(255,0,0,0.4)";
ctx.beginPath();
ctx.arc(sx, sy, e.size * 2, 0, Math.PI * 2);
ctx.stroke();
}
// player
ctx.fillStyle = "#ffcc00";
ctx.beginPath();
ctx.arc(canvas.width / 2, canvas.height / 2, player.size / 2, 0, Math.PI * 2);
ctx.fill();
// minimap
const mmWidth = MAP_W * MINIMAP_TILE;
const mmHeight = MAP_H * MINIMAP_TILE;
const mmX = canvas.width - mmWidth - MINIMAP_MARGIN;
const mmY = MINIMAP_MARGIN;
ctx.save();
ctx.translate(mmX, mmY);
for (let y = 0; y < MAP_H; y++) {
for (let x = 0; x < MAP_W; x++) {
if (map[y][x] === 1) ctx.fillStyle = "#555";
else ctx.fillStyle = "#111";
ctx.fillRect(x * MINIMAP_TILE, y * MINIMAP_TILE, MINIMAP_TILE, MINIMAP_TILE);
}
}
// points on minimap
for (const p of points) {
if (p.collected) continue;
ctx.fillStyle = "#00aaaa";
ctx.fillRect(
p.tx * MINIMAP_TILE,
p.ty * MINIMAP_TILE,
2,
2
);
}
const ptx = player.x / TILE;
const pty = player.y / TILE;
ctx.fillStyle = "#ffff00";
ctx.fillRect(
ptx * MINIMAP_TILE - 2,
pty * MINIMAP_TILE - 2,
4,
4
);
// temporary enemy reveal on minimap
for (const e of enemies) {
if (e.minimapRevealTimer > 0) {
const etx = e.x / TILE;
const ety = e.y / TILE;
ctx.fillStyle = "#ff4444";
ctx.fillRect(
etx * MINIMAP_TILE - 2,
ety * MINIMAP_TILE - 2,
4,
4
);
}
}
ctx.restore();
// timer
const timeLeft = getTimeLeft();
ctx.fillStyle = "#ffffff";
ctx.font = "20px monospace";
ctx.textAlign = "center";
ctx.fillText(
"Survive: " + timeLeft.toFixed(1) + "s",
canvas.width / 2,
30
);
// game over / win text
if (gameOver || win) {
ctx.fillStyle = "rgba(0,0,0,0.6)";
ctx.fillRect(0, 0, canvas.width, canvas.height);
ctx.fillStyle = "#ffffff";
ctx.font = "40px monospace";
ctx.textAlign = "center";
ctx.fillText(
win ? "You survived!" : "Caught...",
canvas.width / 2,
canvas.height / 2
);
}
}
// ---------- LOOP ----------
function loop() {
if (!gameOver && !win) {
handleInput();
movePlayer();
collectPoints();
moveEnemies();
if (checkEnemyCollision() && !gameOver) {
gameOver = true;
deathTime = performance.now();
}
if (getTimeLeft() <= 0) {
win = true;
}
}
if (gameOver && deathTime) {
if (performance.now() - deathTime > 10000) {
location.reload();
}
}
draw();
requestAnimationFrame(loop);
}
loop();
}
if (document.readyState === "complete" || document.readyState === "interactive") {
start();
} else {
document.addEventListener("DOMContentLoaded", start);
}
})();
